import { useState, useCallback } from 'react';
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { message } from 'antd';
import { User } from '../types';
import { 
  getUserList, 
  getUserById,
  addUser, 
  updateUser, 
  deleteUser, 
  updateUserState 
} from '../api/userApi';
import { getRoleList } from '../api/roleApi';
import { getRegions } from '../api/regionApi';

/**
 * 提取API响应中的数据
 * 处理不同的API响应格式
 * @param response API响应
 * @returns 提取的数据
 */
const extractApiData = <T>(response: unknown): T | null => {
  if (!response) return null;
  
  // 处理直接返回数组或对象的情况
  if (Array.isArray(response)) {
    return response as T;
  }
  
  // 处理标准API响应格式
  const apiResponse = response as { data?: unknown; code?: number };
  if (apiResponse.data !== undefined) {
    // 处理嵌套data结构: { data: { data: actualData } }
    if (typeof apiResponse.data === 'object' && 
        apiResponse.data !== null && 
        'data' in apiResponse.data) {
      return (apiResponse.data as Record<string, unknown>).data as T;
    }
    return apiResponse.data as T;
  }
  
  // 如果是对象但不符合API响应格式，直接返回
  if (typeof response === 'object' && response !== null) {
    return response as T;
  }
  
  return null;
};

/**
 * 用户列表钩子
 * @returns 用户列表数据和相关状态
 */
export const useUserList = () => {
  const [searchParams, setSearchParams] = useState<{
    username?: string;
    roleId?: number;
    region?: string;
  }>({});
  
  // 获取用户列表
  const { 
    data: users, 
    isLoading, 
    error, 
    refetch 
  } = useQuery({
    queryKey: ['users', searchParams],
    queryFn: async () => {
      console.log('开始获取用户列表');
      const res = await getUserList();
      console.log('用户列表API返回:', res);
      
      // 处理响应数据格式
      let userData: User[] = [];
      
      // 使用统一的数据提取函数
      userData = extractApiData<User[]>(res) || [];
      
      // 确保每个用户对象都有一个id字段和seqId字段
      return userData.map(user => {
        // 创建一个用户对象的副本，避免修改原始数据
        const processedUser = { ...user };

        // 如果有_id但没有id，则将_id作为id
        if (user._id && !user.id) {
          processedUser.id = user._id;
        }
        
        // 如果既没有id也没有_id，生成一个临时id
        if (!processedUser.id && !processedUser._id) {
          console.warn('用户数据缺少ID字段:', user);
          processedUser.id = `temp-${Math.random().toString(36).substr(2, 9)}`;
        }

        // 如果没有seqId，尝试使用其他字段或生成一个临时值
        if (!processedUser.seqId) {
          // 根据业务逻辑优先级确定seqId值
          if (typeof user.seqId === 'number') {
            processedUser.seqId = user.seqId;
          } else if (typeof user.id === 'number') {
            processedUser.seqId = user.id;
          } else {
            // 生成一个临时值，实际应用中应避免此情况
            console.warn('用户数据缺少seqId字段，使用临时值:', user);
            processedUser.seqId = Math.floor(Math.random() * 1000000);
          }
        }

        console.log('处理后的用户数据:', processedUser);
        return processedUser;
      });
    }
  });
  
  // 根据搜索条件过滤用户列表
  const getFilteredUserList = useCallback(() => {
    if (!users) return [];
    
    // 使用后端返回的已过滤结果，只添加搜索过滤
    return users.filter(user => {
      let matches = true;
      
      if (searchParams.username && user.username) {
        matches = matches && user.username.toLowerCase().includes(searchParams.username.toLowerCase());
      }
      
      if (searchParams.roleId) {
        const userRoleId = user.roleId || user.role?.id;
        matches = matches && userRoleId === searchParams.roleId;
      }
      
      if (searchParams.region && user.region) {
        matches = matches && user.region === searchParams.region;
      }
      
      return matches;
    });
   
  }, [users, searchParams.username, searchParams.roleId, searchParams.region]);
  
  // 提供搜索功能
  const handleSearch = (params: { username?: string; roleId?: number; region?: string }) => {
    setSearchParams(params);
  };
  
  return {
    users: getFilteredUserList(),
    rawUsers: users || [],
    isLoading,
    error,
    refetch,
    handleSearch,
    searchParams
  };
};

/**
 * 获取用户详情
 * @param id 用户ID
 * @returns 用户详情
 */
export const useUserDetail = (id?: string | number) => {
  return useQuery({
    queryKey: ['user', id],
    queryFn: async () => {
      if (!id) return null;
      try {
        // 使用专用的用户详情API获取完整信息
        const res = await getUserById(id);
        console.log('用户详情API返回:', res);
        
        // 使用统一的数据提取函数
        return extractApiData<User>(res);
      } catch (error) {
        console.error('获取用户详情失败:', error);
        return null;
      }
    },
    enabled: !!id
  });
};

/**
 * 添加用户钩子
 * @returns 添加用户函数和状态
 */
export const useAddUser = () => {
  const queryClient = useQueryClient();
  
  return useMutation({
    mutationFn: (userData: Omit<User, 'id'>) => addUser(userData),
    onSuccess: () => {
      message.success('用户添加成功');
      queryClient.invalidateQueries({ queryKey: ['users'] });
    },
    onError: (error) => {
      message.error(`用户添加失败: ${error instanceof Error ? error.message : '未知错误'}`);
    }
  });
};

/**
 * 更新用户钩子
 * @returns 更新用户函数和状态
 */
export const useUpdateUser = () => {
  const queryClient = useQueryClient();
  
  return useMutation({
    mutationFn: ({ id, data }: { id: string | number, data: Partial<User> }) => 
      updateUser(id, data),
    onSuccess: () => {
      message.success('用户更新成功');
      queryClient.invalidateQueries({ queryKey: ['users'] });
    },
    onError: (error) => {
      message.error(`用户更新失败: ${error instanceof Error ? error.message : '未知错误'}`);
    }
  });
};

/**
 * 更新用户状态钩子
 * @returns 更新用户状态函数和状态
 */
export const useUpdateUserState = () => {
  const queryClient = useQueryClient();
  
  return useMutation({
    mutationFn: ({ id, roleState }: { id: string | number, roleState: boolean }) => 
      updateUserState(id, roleState),
    onSuccess: (_, variables) => {
      message.success(`用户${variables.roleState ? '启用' : '禁用'}成功`);
      queryClient.invalidateQueries({ queryKey: ['users'] });
    },
    onError: (error) => {
      message.error(`操作失败: ${error instanceof Error ? error.message : '未知错误'}`);
    }
  });
};

/**
 * 删除用户钩子
 * @returns 删除用户函数和状态
 */
export const useDeleteUser = () => {
  const queryClient = useQueryClient();
  
  return useMutation({
    mutationFn: (id: string | number) => {
      // 确保id不是undefined
      if (id === undefined) {
        throw new Error('用户ID不能为空');
      }
      return deleteUser(id);
    },
    onSuccess: () => {
      message.success('用户删除成功');
      queryClient.invalidateQueries({ queryKey: ['users'] });
    },
    onError: (error) => {
      message.error(`用户删除失败: ${error instanceof Error ? error.message : '未知错误'}`);
    }
  });
};

/**
 * 获取角色列表钩子
 * @returns 角色列表
 */
export const useRoleList = () => {
  return useQuery({
    queryKey: ['roles'],
    queryFn: async () => {
        console.log('开始获取角色列表');
        const res = await getRoleList();
        console.log('角色列表API返回:', res);
      return res || [];
    }
  });
};

/**
 * 获取区域列表钩子
 * @returns 区域列表
 */
export const useRegionList = () => {
  return useQuery({
    queryKey: ['regions'],
    queryFn: async () => {
        console.log('开始获取区域列表');
        const res = await getRegions();
        console.log('区域列表API返回:', res);
      return res || [];
    }
  });
};

export default {
  useUserList,
  useUserDetail,
  useAddUser,
  useUpdateUser,
  useUpdateUserState,
  useDeleteUser,
  useRoleList,
  useRegionList
}; 
